"""
定义一个类
1. 定一初始化方法:
    1.1 获取所有的测试用例,并绑定为实例属性

2. 定义一个方法: 根据当前的用例(外界传递一个字典进来)id,执行依赖前置用例并替换依赖字段:value,header
    2.1 获取用于判断当前接口是否有前置依赖的关键字段:value,header,rely,caseid
    2.2 判断是否有前置用例(rely是否是y),判断caseid是否有值?:
        2.2.1 有依赖:根据正则表达式找出请求头/体里面依赖的字段: 可以封装一个独立方法进行调用
        2.2.2 执行前置用例得到前置用例的返回结果,在结果内根据上一步找到的依赖字段获取响应里面对应的实际数据: 可以封装一个独立方法进行调用
        2.2.3 上一步获取的依赖的实际结果,替换原来的数据
        2.2.4 返回替换好的header和value
    2.3 没有依赖, 直接返回当前的header和value

3. 定义一个方法:根据需求提取出需要依赖的请求头/体里面的依赖字段:
    3.1 根据正则表达式提取依赖字段:得到一个列表
    3.2 判断得到的列表是否有数据
        3.2.1 是: 返回依赖的字段
        3.2.2 否: 返回None

4. 定义一个方法: 执行前置用例,根据准备好的目标字段获取实际数据:请求头/体
    4.1 准备前置用例请求所需要的数据
    4.2 调用configHttp进行接口请求,并获得返回结果:res
    4.3 判断请求头里面是否有依赖字段,有的话取出依赖的字段内容
    4.4 判断请求体里面是否有依赖字段,有的话取出依赖的字段内容
    4.5 返回给外界得到的依赖数据: 头 , 体
"""
import re, jsonpath
from common.confighttp import CinfigHttp


# 定义一个类
class PreSolve:
    # 1. 定一初始化方法:
    def __init__(self, testdata):
        # 1.1 获取所有的测试用例,并绑定为实例属性
        self.testdata = testdata

    # 2. 定义一个方法: 根据当前的用例(外界传递一个字典进来)id,执行依赖前置用例并替换依赖字段:value,header
    def pre_solve(self, dic):
        # 2.1 获取用于判断当前接口是否有前置依赖的关键字段:value,header,rely,caseid
        rely, caseid, value, header = dic["rely"], dic["caseid"], dic["value"], dic["header"]
        print(rely, caseid, value, header)
        # 2.2 判断是否有前置用例(rely是否是y),判断caseid是否有值?:
        if rely.lower() == "y" and caseid != "":
            # 2.2.1 有依赖:根据正则表达式找出请求头/体里面依赖的字段: 可以封装一个独立方法进行调用
            goal_header = self.get_predata(header)
            goal_body = self.get_predata(value)
            print(f"====>依赖的字段:{goal_header},{goal_body}")
            # 2.2.2 执行前置用例得到前置用例的返回结果,在结果内根据上一步找到的依赖字段获取响应里面对应的实际数据: 可以封装一个独立方法进行调用
            h, b = self.run_pre(caseid, goal_header, goal_body)
            # 2.2.3 上一步获取的依赖的实际结果,替换原来的数据
            if h != None:
                header = header.replace("${" + goal_header + "}", h)
            if b != None:
                value = value.replace("${" + goal_body + "}", b)
            # 2.2.4 返回替换好的header和value
            return header, value
        # 2.3 没有依赖, 直接返回当前的header和value
        else:
            return header, value

    # 3. 定义一个方法:根据需求提取出需要依赖的请求头/体里面的依赖字段:
    @staticmethod
    def get_predata(data):
        # 3.1 根据正则表达式提取依赖字段:得到一个列表
        res = re.findall(r"\${(.*?)}", data)
        # 3.2 判断得到的列表是否有数据
        if len(res) != 0:
            # 3.2.1 是: 返回依赖的字段
            return res[0]
        # 3.2.2 否: 返回None

    # 4. 定义一个方法: 执行前置用例,根据准备好的目标字段获取实际数据:请求头/体
    def run_pre(self, caseid, goal_header=None, goal_body=None):
        # 4.1 准备前置用例请求所需要的数据
        data = self.testdata[int(caseid) - 1]
        # 4.2 调用configHttp进行接口请求,并获得返回结果:res
        ch = CinfigHttp(data)
        res = ch.run()
        # 4.3 判断请求头里面是否有依赖字段,有的话取出依赖的字段内容
        if goal_header != None:
            goal_header = res.headers[goal_header]
        # 4.4 判断请求体里面是否有依赖字段,有的话取出依赖的字段内容
        if goal_body != None:
            goal_body = jsonpath.jsonpath(res.json(), f"$..{goal_body}")[0]
        # 4.5 返回给外界得到的依赖数据: 头 , 体
        return goal_header, goal_body


if __name__ == '__main__':
    from common.readData import ReadData

    rd = ReadData()
    data = rd.read_excel()
    # 调试当前类
    ps = PreSolve(data)
    # print(ps.pre_solve(data[0]))
    print(ps.pre_solve(data[4]))
    print(ps.pre_solve(data[3]))
    # 调试第二个方法:get_predata
    # str1 = "{'name':'${username}','link':'www.baidu.com'}"
    # str2 = '{"cookie":"${Set-Cookie}"}'
    # str3 = "{'username':'liangchao','password':'123456'}"
    # print(ps.get_predata(str1))
    # print(ps.get_predata(str2))
    # print(ps.get_predata(str3))
    # 调试第三个方法
    # print(ps.run_pre("1",goal_header="Set-Cookie",goal_body="username"))
